/**
 * Winston日志工具
 * 提供结构化日志记录、日志轮转和敏感数据脱敏功能
 */

import winston from 'winston';
import DailyRotateFile from 'winston-daily-rotate-file';
import path from 'path';
import { fileURLToPath } from 'url';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

// 日志目录
const logsDir = path.join(__dirname, '../../logs');

/**
 * 敏感数据脱敏
 * @param {any} data - 要脱敏的数据
 * @returns {any} 脱敏后的数据
 */
const maskSensitiveData = (data) => {
  if (!data) return data;

  // 如果是字符串，直接返回
  if (typeof data === 'string') {
    return data;
  }

  // 如果是数组，递归处理
  if (Array.isArray(data)) {
    return data.map(maskSensitiveData);
  }

  // 如果是对象，处理敏感字段
  if (typeof data === 'object') {
    const masked = { ...data };
    const sensitiveFields = [
      'password',
      'token',
      'authorization',
      'apiKey',
      'api_key',
      'secret',
      'accessToken',
      'refreshToken',
    ];

    for (const field of sensitiveFields) {
      if (masked[field]) {
        masked[field] = '***MASKED***';
      }
      // 处理大小写变体
      const lowerField = field.toLowerCase();
      if (masked[lowerField]) {
        masked[lowerField] = '***MASKED***';
      }
    }

    // 递归处理嵌套对象
    for (const key in masked) {
      if (typeof masked[key] === 'object' && masked[key] !== null) {
        masked[key] = maskSensitiveData(masked[key]);
      }
    }

    return masked;
  }

  return data;
};

/**
 * 自定义日志格式
 */
const customFormat = winston.format.combine(
  winston.format.timestamp({
    format: 'YYYY-MM-DD HH:mm:ss.SSS',
  }),
  winston.format.errors({ stack: true }),
  winston.format.splat(),
  winston.format.json(),
  winston.format.printf((info) => {
    const { timestamp, level, message, ...meta } = info;

    // 脱敏元数据
    const maskedMeta = maskSensitiveData(meta);

    return JSON.stringify({
      timestamp,
      level,
      message,
      ...maskedMeta,
    });
  })
);

/**
 * 控制台日志格式（更易读）
 */
const consoleFormat = winston.format.combine(
  winston.format.colorize(),
  winston.format.timestamp({
    format: 'YYYY-MM-DD HH:mm:ss',
  }),
  winston.format.printf((info) => {
    const { timestamp, level, message, ...meta } = info;
    let metaStr = '';

    if (Object.keys(meta).length > 0) {
      metaStr = ` ${JSON.stringify(maskSensitiveData(meta))}`;
    }

    return `${timestamp} [${level}]: ${message}${metaStr}`;
  })
);

/**
 * 通用日志文件配置
 */
const commonFileOptions = {
  datePattern: 'YYYY-MM-DD',
  zippedArchive: true,
  maxSize: '100m',
  maxFiles: '30d',
  format: customFormat,
};

/**
 * Winston Logger实例
 */
const logger = winston.createLogger({
  level: process.env.LOG_LEVEL || 'info',
  format: customFormat,
  transports: [
    // 控制台输出
    new winston.transports.Console({
      format: consoleFormat,
      silent: process.env.NODE_ENV === 'test', // 测试环境禁用控制台输出
    }),

    // 所有日志文件（每天轮转）
    new DailyRotateFile({
      ...commonFileOptions,
      filename: path.join(logsDir, 'application-%DATE%.log'),
      level: 'info',
    }),

    // 错误日志文件（单独记录）
    new DailyRotateFile({
      ...commonFileOptions,
      filename: path.join(logsDir, 'error-%DATE%.log'),
      level: 'error',
    }),

    // 性能日志文件（单独记录）
    new DailyRotateFile({
      ...commonFileOptions,
      filename: path.join(logsDir, 'performance-%DATE%.log'),
      level: 'info',
      // 只记录包含performance标记的日志
      filter: (info) => info.performance === true,
    }),
  ],
});

/**
 * 日志记录辅助函数
 */
export const log = {
  /**
   * 调试日志
   */
  debug: (message, meta = {}) => {
    logger.debug(message, meta);
  },

  /**
   * 信息日志
   */
  info: (message, meta = {}) => {
    logger.info(message, meta);
  },

  /**
   * 警告日志
   */
  warn: (message, meta = {}) => {
    logger.warn(message, meta);
  },

  /**
   * 错误日志
   */
  error: (message, meta = {}) => {
    if (meta.error && meta.error.stack) {
      logger.error(message, {
        ...meta,
        stack: meta.error.stack,
      });
    } else {
      logger.error(message, meta);
    }
  },

  /**
   * 性能日志（专门用于记录性能指标）
   */
  performance: (message, metrics = {}) => {
    logger.info(message, {
      ...metrics,
      performance: true, // 标记为性能日志
    });
  },
};

/**
 * 创建子logger（用于特定模块）
 */
export const createChildLogger = (module) => {
  return {
    debug: (message, meta = {}) => log.debug(message, { module, ...meta }),
    info: (message, meta = {}) => log.info(message, { module, ...meta }),
    warn: (message, meta = {}) => log.warn(message, { module, ...meta }),
    error: (message, meta = {}) => log.error(message, { module, ...meta }),
    performance: (message, metrics = {}) =>
      log.performance(message, { module, ...metrics }),
  };
};

// 导出logger实例和辅助函数
export default logger;
export { maskSensitiveData };

